/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.jomijushi.fid.interfaz;


import com.jomijushi.fid.dao.ClienteImplementsDAO;
import com.jomijushi.fid.dao.ClienteInterfazDAO;
import com.jomijushi.fid.dao.PersonaEmpresaImplementsDAO;
import com.jomijushi.fid.dao.PersonaEmpresaInterfazDAO;
import com.jomijushi.fid.dominio.FidCliente;
import com.jomijushi.fid.dominio.FidPersonaEmpresa;
import com.jomijushi.fid.dominio.FidProductoMercaderia;
import com.jomijushi.fid.dominio.FidProductoServicio;
import com.jomijushi.fid.dominio.FidProductoVenta;
import com.jomijushi.fid.dominio.FidProveedor;
import com.jomijushi.fid.dominio.FidRolTrabajador;
import com.jomijushi.fid.dominio.FidServicioDefinidoEdicion;
import com.jomijushi.fid.dominio.FidServicioDefinidoImpresion;
import com.jomijushi.fid.dominio.FidTrabajador;
import com.jomijushi.fid.dominio.FidBobina;
import com.jomijushi.fid.dominio.FidComplejidadImpresion;
import com.jomijushi.fid.dominio.FidDimensionFoto;
import com.jomijushi.fid.dominio.FidEstado;
import com.jomijushi.fid.dominio.FidItemVenta;
import com.jomijushi.fid.dominio.FidPedidoVenta;
import com.jomijushi.fid.dominio.FidTareaItem;
import com.jomijushi.fid.dominio.FidTipoCliente;
import com.jomijushi.fid.dominio.FidTipoImpresion;
import com.jomijushi.fid.servicios.BobinaImplementsService;
import com.jomijushi.fid.servicios.ClienteImplementsService;
import com.jomijushi.fid.servicios.ClienteInterfazService;
import com.jomijushi.fid.servicios.ComplejidadImpresionImplementsService;
import com.jomijushi.fid.servicios.DimensionFotoImplementsService;
import com.jomijushi.fid.servicios.EstadoImplementsService;
import com.jomijushi.fid.servicios.ItemVentaImplementsService;
import com.jomijushi.fid.servicios.PedidoVentaImplementsService;
import com.jomijushi.fid.servicios.PersonaEmpresaImplementsService;
import com.jomijushi.fid.servicios.PersonaEmpresaInterfazService;
import com.jomijushi.fid.servicios.ProductoVentaImplementsService;
import com.jomijushi.fid.servicios.ProductoVentaInterfazService;
import com.jomijushi.fid.servicios.ProveedorImplementsService;
import com.jomijushi.fid.servicios.ProveedorInterfazService;
import com.jomijushi.fid.servicios.TareaItemImplementsService;
import com.jomijushi.fid.servicios.TareaItemInterfazService;
import com.jomijushi.fid.servicios.TipoClienteImplementsService;
import com.jomijushi.fid.servicios.TrabajadorImplementsService;
import com.jomijushi.fid.servicios.TrabajadorInterfazService;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.swing.JOptionPane;


/**
 *
 * @author Jorge Valverde Rebaza
 */
public class Main {

    private static EntityManagerFactory emf;


    /**
     * @param args the command line arguments
     */

    // ESTE ES EL NUEVO MAIN
    public static void main(String[] args) {
        emf = Persistence.createEntityManagerFactory("fid.netPU");
        // Para probar los CRUD tienes que descomentar las funciones que deseas probar

        // CRUD ROL TRABAJADOR

            // 1 Crear
            /*
            FidRolTrabajador frt = new FidRolTrabajador();
            frt.setNombre("Impresor");
            frt.setDescripcion("Encargado de imprimir las fotos");
            crearRolTrabajador(frt);
            */

            // 2 Buscar
            /*
            FidRolTrabajador frt = new FidRolTrabajador();
            frt = buscarFidRolTrabajador(2);
            System.out.println("Rol: "+frt.getNombre());
            System.out.println("Descripcion: "+frt.getDescripcion());
            */

            // 3 Editar
            /*
            FidRolTrabajador frt = new FidRolTrabajador();
            frt = buscarFidRolTrabajador(2);
            frt.setNombre("Editor");
            frt.setDescripcion("Encargado de Editar las fotos");
            editarRolTrabajador(frt);
            */

            // 4 Eliminar
            //eliminarFidRolTrabajador(1);

            // 5 Listar
            //                                              band  consulta todo valores
           /*
            List<FidRolTrabajador> lfrt = listarRolTrabajador(false,"", true, 0,0);
            for(int i=0; i<4;i++)
            {
                FidRolTrabajador frt = lfrt.get(i);
                System.out.println("************************");
                System.out.println("Rol         : "+ frt.getNombre());
                System.out.println("Descripcion : "+ frt.getDescripcion());
            }
            */


        // CRUD TRABAJADOR

        

        //prueba de trabajador
       /* PersonaEmpresaInterfazService workservice = new PersonaEmpresaImplementsService();
        workservice.setEntityManagerFactory(emf);
         // fidTrabajador es una clase de tipo FidTrabajador definido como atributo en FidPersonaEmpresa
        FidTrabajador trabajador = (FidTrabajador)workservice.buscar("fidTrabajador","dniRuc","43529862");
        if(trabajador==null)
        {
            System.out.println("VACIO");
        }else
        {
            System.out.println("Este es mi trabajador = "+trabajador.getNombres());
        }
           */





        /*

        //prueba de reporte global d etrabajadores: JCW :D
        String keyword = "dniRuc";
        String valorKey = null;  //si no s ebuscara por algop especifico debe ser null
        String ordenarBy = "nombres";
        String criterioOrden="asc";
        boolean verTodo = true;
        boolean isLike = false;
        int limInf = 0;
        int limSup = 10;
    
        PersonaEmpresaInterfazService workservice = new PersonaEmpresaImplementsService();
        workservice.setEntityManagerFactory(emf);
        List<FidPersonaEmpresa> lst = workservice.reportar(keyword, valorKey, ordenarBy, criterioOrden, verTodo, isLike, limInf, limSup);
        System.out.println("\n----------------\nReporte global de todos los elementos padre");
        for(int i=0; i<lst.size(); i++)
            System.out.println("trabajador = "+lst.get(i).getNombres());




        System.out.println("\n----------------\nReporte global de todos los elementos hijo exclusivamente");
        PersonaEmpresaInterfazService workservice2 = new PersonaEmpresaImplementsService();
        workservice2.setEntityManagerFactory(emf);
        List<FidPersonaEmpresa> lst2 = workservice2.reportar("FidTrabajador",keyword, valorKey, ordenarBy, criterioOrden, verTodo, isLike, limInf, limSup);

        for(int i=0; i<lst2.size(); i++){
            FidTrabajador worker = (FidTrabajador)lst2.get(i);
            System.out.println("trabajador = "+worker.getNombres()+" dni = "+worker.getDniRuc()+" usuario = "+worker.getUsuario());
        }



        //////////////buskeda con demas criterios
        keyword = "dniRuc";
        valorKey = "56";  //si no se buscara por algo especifico debe ser null
        ordenarBy = "nombres";
        criterioOrden="";
        verTodo = false;  //uso false porke quiero un reporte paginado
        isLike = true;  //en este caso buscaremos los dnis que contengan "56"
        limInf = 0;
        limSup = 3;
        System.out.println("\n----------------\nReporte usando like ");
        PersonaEmpresaInterfazService workservice3 = new PersonaEmpresaImplementsService();
        workservice3.setEntityManagerFactory(emf);
        List<FidPersonaEmpresa> lst3 = workservice3.reportar("FidTrabajador",keyword, valorKey, ordenarBy, criterioOrden, verTodo, isLike, limInf, limSup);

        for(int i=0; i<lst3.size(); i++){
            FidTrabajador worker = (FidTrabajador)lst3.get(i);
            System.out.println("trabajador = "+worker.getNombres()+" dni = "+worker.getDniRuc()+" usuario = "+worker.getUsuario());
        }*/

        
        

        //pedido de Pedro
     /*    ProductoVentaInterfazService sproducto = new ProductoVentaImplementsService();
         sproducto.setEntityManagerFactory(emf);

         System.out.println("Reporte de FidProductoVenta");
         List<FidProductoVenta> lst4 = sproducto.reportar("FidProductoMercaderia", "createdAt", null, "", "", true, false, -1, -1);
         if(lst4.size()==0)
             System.out.println("Lista vacia");
         for(int i=0; i<lst4.size(); i++){         
             FidProductoMercaderia servicio = (FidProductoMercaderia)lst4.get(i);
             System.out.println(servicio.getDescripcion()+"  "+servicio.getFidCategoriaProductoId().getNombre());
         }

*/

        //nuevo test: JCW
        //crearProductoServicio();
        reportarFidServicioDefinidoImpresion();
        //crearTareaItem();


   

    }



    //Jorge Valverde: crear producto servicio
    public static void crearProductoServicio(){
        //1º buscamos la dimension de la foto
        System.out.println("Dimension Foto");
        DimensionFotoImplementsService dimensionFotoService = new DimensionFotoImplementsService();
        dimensionFotoService.setEntityManagerFactory(emf);
        int idDimension = 1;  //jumbo
        FidDimensionFoto dimensionFoto = dimensionFotoService.buscar(idDimension);
        System.out.println("El nombre de la dimensionFoto es = "+dimensionFoto.getNombre());

        //2º buscamos el tipo de cliente
        System.out.println("Tipo Cliente");
        TipoClienteImplementsService tipoclienteService = new TipoClienteImplementsService();
        tipoclienteService.setEntityManagerFactory(emf);
        int idTipoCliente = 2; //tipo CONFIANZA
        FidTipoCliente tipoCliente = tipoclienteService.buscar(idTipoCliente);
        System.out.println("El nombre del tipo de cliente es = "+tipoCliente.getNombre());


        //3º buscamos la complejidad de impresion
         System.out.println("Complejidad impresion");
         ComplejidadImpresionImplementsService complejidadImpresionService = new ComplejidadImpresionImplementsService();
         complejidadImpresionService.setEntityManagerFactory(emf);
         int idComplejidad = 2; //regular
         FidComplejidadImpresion complejidadImpresion = complejidadImpresionService.buscar(idComplejidad);
         System.out.println("El nombre de la complejidad es = "+complejidadImpresion.getNombre());


        //4º buscamos la bobina
        System.out.println("Bobina");
        BobinaImplementsService bobinaService = new BobinaImplementsService();
        bobinaService.setEntityManagerFactory(emf);
        int idBobina = 1;
        FidBobina bobina = bobinaService.buscar(idBobina);
          System.out.println("El area de riesgo de la bobina es = "+bobina.getAreaRiesgo());
        //3º creamos un producto servicio

        FidServicioDefinidoImpresion productoServicio = new FidServicioDefinidoImpresion();
        productoServicio.setFidDimensionFotoId(dimensionFoto);
        productoServicio.setFidTipoClienteId(tipoCliente);
        Date fecha = new Date();
        productoServicio.setFechaEntrada(fecha);
        productoServicio.setCreatedAt(fecha);
        productoServicio.setUpdatedAt(fecha);
        productoServicio.setCreatedAtProductoServicio(fecha);
        productoServicio.setUpdatedAtProductoServicio(fecha);
        productoServicio.setCreatedAtServicioDefinidoImpresion(fecha);
        productoServicio.setCreatedAtServicioDefinidoImpresion(fecha);
        productoServicio.setFidComplejidadImpresionId(complejidadImpresion);
        productoServicio.setFidBobinaId(bobina);
        productoServicio.setPrecio(2.5);
        productoServicio.setOfertar(false);  //no ofertar


        //4º guardamos en la BD
        ProductoVentaImplementsService productoVentaService = new ProductoVentaImplementsService();
        productoVentaService.setEntityManagerFactory(emf);
        productoVentaService.registrar(productoServicio);

        System.out.println("Se inserto un producto servicio definido impresion");
    }


    public static void reportarFidServicioDefinidoImpresion(){
        ProductoVentaImplementsService productoVentaService = new ProductoVentaImplementsService();
        productoVentaService.setEntityManagerFactory(emf);
        Double precio = new Double(0.5);
       
        List<FidProductoVenta> lstProductoVenta = productoVentaService.reportar("FidServicioDefinidoImpresion","", null, "precio", "desc", true, false, -1, -1);

        System.out.println("Reportando");
        for(int i=0; i<lstProductoVenta.size(); i++){
            FidServicioDefinidoImpresion servicioImpresion = (FidServicioDefinidoImpresion)lstProductoVenta.get(i);
            System.out.println("Su id es = "+servicioImpresion.getFidProductoVentaId()+"     su precio es = "+servicioImpresion.getPrecio());
        }    
    }


    public static void crearTareaItem(){        
        //1ª necesitamos de un estado
        System.out.println("\n***** En Estado");
        EstadoImplementsService estadoService = new EstadoImplementsService();
        estadoService.setEntityManagerFactory(emf);
         //buscamos el estado con un determinado id
        int id = 1;  //estos son todos los estados RECEPCIONADOS
        FidEstado estado = estadoService.buscar(id);        
        System.out.println("El nombre del estado es = "+estado.getNombre());


        //2ª buscamos la venta a la que atenderemos
        System.out.println("\n***** En PedidoVenta");
        PedidoVentaImplementsService pedidoVentaService = new PedidoVentaImplementsService();
        pedidoVentaService.setEntityManagerFactory(emf);
        int idVenta = 1;  //sera mi id de venta
        FidPedidoVenta pedidoVenta = pedidoVentaService.buscar(idVenta);
        System.out.println("El cliente que hizo el pedido es: "+pedidoVenta.getFidClienteFidPersonaEmpresaId().getNombres());
        System.out.println("El id del pedido venta es = "+pedidoVenta.getId());


        //3º sacamos el item del pedido venta
        System.out.println("\n***** En ItemVenta");
        ItemVentaImplementsService itemVentaService = new ItemVentaImplementsService();
        itemVentaService.setEntityManagerFactory(emf);
        List<FidItemVenta>lstItemsVenta = itemVentaService.reportar("fidPedidoVentaId",pedidoVenta ,"id", "asc", true, false, -1, -1);

       for(int i=0; i<lstItemsVenta.size(); i++){
           FidItemVenta itemVenta = (FidItemVenta)lstItemsVenta.get(i);
           System.out.println("El id del item es = "+itemVenta.getId()+"\nLa descripcion del item venta es = "+itemVenta.getDescripcion());
       }
        //4º la tarea a insertar
        FidTareaItem tareaItem = new FidTareaItem();
        tareaItem.setFecha(new Date());
        tareaItem.setFidEstadoId(estado);
        //tareaItem.setFidItemVentaId(fidItemVentaId)
        //tareaItemService.registrar(entity);

          TareaItemImplementsService tareaItemService = new TareaItemImplementsService();
        //creacion de una tareaItem

          
    }










    
   //Impresion
   public static void crearProducto(){
       FidServicioDefinidoEdicion fidServicioDefinidoEdicion = new FidServicioDefinidoEdicion();
       fidServicioDefinidoEdicion.setOfertar(Boolean.TRUE);
       crearProducto(fidServicioDefinidoEdicion);
   }
   public static void crearProducto(FidProductoVenta fidProductoVenta)
   {
       ProductoVentaInterfazService fidProductoVentaInterfazService = new ProductoVentaImplementsService();
       fidProductoVentaInterfazService.setEntityManagerFactory(emf);
       fidProductoVentaInterfazService.registrar(fidProductoVenta);
   }

        /*System.out.println("****Crearemos un nuevo Servicio Definido Edicion*******");
        FidServicioDefinidoEdicion servicioDefinidoEdicion = new FidServicioDefinidoEdicion();
        servicioDefinidoEdicion.setOfertar(Boolean.TRUE);
        servicioDefinidoEdicion.setPrecio(633.0);
        ProductoVentaInterfazService serviceProd = new ProductoVentaImplementsService();
        serviceProd.setEntityManagerFactory(emf);
        serviceProd.registrarProducto(servicioDefinidoEdicion);*/

    //FID PROVEEDOR
   /* public static void crearProveedor(){
        System.out.println("****Crearemos un nuevo Proveedor");
        String nombres = "Almacenes de Tintas";
        String ruc = "85746525123";
        String email = "contacto@almacenes.com";
        String telefono ="821445";
        String direccion = "casa del almacen 345";
        String descripcion = "Empresa proveedor de tinta de impresion";
        FidProveedor proveedor = new FidProveedor();
        proveedor.setNombres(nombres);
        proveedor.setDniRuc(ruc);
        proveedor.setEmail(email);
        proveedor.setDireccion(direccion);
        proveedor.setDescripcion(descripcion);
        proveedor.setCreatedAt(new Date());
        proveedor.setCantCompras(0);

        ProveedorInterfazService serviceProv = new ProveedorImplementsService();
        serviceProv.setEntityManagerFactory(emf);
        serviceProv.crearProveedor(proveedor);

    }

    public static void editarProveedor(){
         int id = 16;
        EntityManager em = emf.createEntityManager();
        FidProveedor proveedor = em.getReference(FidProveedor.class, id);
        proveedor.setDireccion("nueva direccion");
        proveedor.setUpdatedAt(new Date());
        ProveedorInterfazService serviceProv = new ProveedorImplementsService();
        serviceProv.setEntityManagerFactory(emf);
        serviceProv.modificarProveedor(proveedor);
    }

    public static void eliminarProveedor(){
        int id = 16;
        EntityManager em = emf.createEntityManager();
        FidProveedor proveedor = em.getReference(FidProveedor.class, id);
        System.out.println("Eliminaremos al proveedor = "+proveedor.getNombres());
        ProveedorInterfazService serviceProv = new ProveedorImplementsService();
        serviceProv.setEntityManagerFactory(emf);
        serviceProv.eliminarProveedor(proveedor);
    }

    public static void listarProveedores(){

        //Si dejamos todas las variables String en blanco (por defecto se ordena por nombre)
        //entonces se reportaran todos los elementos salvo que los limitemos
      /*  String criterio = "";  //elemento de la clase FidProveedor
        String keyword = "";
        String ordenarBy="";
        String criterioOrden="";
        boolean todo=true;  //true para ver todo, false para paginar segun los limites
        int limInf = 0;
        int limSup = 1;


        String criterio = "nombres";  //elemento de la clase FidProveedor
        String keyword = "S.A.";   //por ejemplo los ruc que contengan el 10
        String ordenarBy="email";  //por ejemplo ordenaremos por email
        String criterioOrden="desc"; //"asc"; //por orden descendiente o ascendiente
        boolean todo=true;  //true para ver todo, false para paginar segun los limites
        int limInf = 0;
        int limSup = 1;

        ProveedorInterfazService serviceProv = new ProveedorImplementsService();
        serviceProv.setEntityManagerFactory(emf);
        List<FidProveedor> lstProveedor = serviceProv.listarProveedores(criterio, keyword, ordenarBy, criterioOrden, todo, limInf, limSup);

        System.out.println("Reportando proveedores");
        for(int i=0; i<lstProveedor.size(); i++){
            System.out.println("-----------\nid = "+lstProveedor.get(i).getId());
            System.out.println("nombres = "+lstProveedor.get(i).getNombres());
            System.out.println("ruc = "+lstProveedor.get(i).getDniRuc());
            System.out.println("cantidad de compras  = "+lstProveedor.get(i).getCantCompras());
        }

    }

*/

    // FID CLIENTE


   /* public static void crearProductoDefinidoImpresion(){
        System.out.println("****Creando Producto");
        FidServicioDefinidoImpresion newFidServicioDefinidoImpresion = new FidServicioDefinidoImpresion();
        ProductoVentaInterfazService productoVentaInterfazService = new ProductoVentaImplementsService();
        productoVentaInterfazService.setEntityManagerFactory(emf);
        newFidServicioDefinidoImpresion = (FidServicioDefinidoImpresion) productoVentaInterfazService.buscarProductoPorId(17);
        newFidServicioDefinidoImpresion.setPrecio(03.0);
        productoVentaInterfazService.editarProducto(newFidServicioDefinidoImpresion);
    }
    public static void editarProducto(){
        System.out.println("****Modificar Producto");
        FidServicioDefinidoImpresion newFidServicioDefinidoImpresion = new FidServicioDefinidoImpresion();
        ProductoVentaInterfazService productoVentaInterfazService = new ProductoVentaImplementsService();
        productoVentaInterfazService.setEntityManagerFactory(emf);
        newFidServicioDefinidoImpresion = (FidServicioDefinidoImpresion) productoVentaInterfazService.buscarProductoPorId(17);
        newFidServicioDefinidoImpresion.setPrecio(03.0);
        productoVentaInterfazService.editarProducto(newFidServicioDefinidoImpresion);
    }

     public static void removerProducto(){
        System.out.println("****Remover Producto");
        FidServicioDefinidoImpresion newFidServicioDefinidoImpresion = new FidServicioDefinidoImpresion();
        ProductoVentaInterfazService productoVentaInterfazService = new ProductoVentaImplementsService();
        productoVentaInterfazService.setEntityManagerFactory(emf);
        newFidServicioDefinidoImpresion = (FidServicioDefinidoImpresion) productoVentaInterfazService.buscarProductoPorId(17);
        System.out.println("****Borrando un producto*******" + newFidServicioDefinidoImpresion);
        productoVentaInterfazService.removerProducto(newFidServicioDefinidoImpresion);
    }*/

    public static void crearCliente()
    {
        System.out.println("****Crearemos un nuevo Cliente");
        String nombres = "Juan Grados";
        String dni = "45857402";
        String email = "juaninf@hotmail.com";
        String telefono ="28585";
        //Date fecha_nacimiento = new Date(834,4,29);
        String direccion = "Barraza";
        //String tipo = "persona";
        String descripcion = "Bachiller en Ciencias de la Computación";

        FidCliente cliente = new FidCliente();
        FidCliente cliente2 = new FidCliente();
        cliente.setCantVentas(0);
        cliente.setSaldo(0.0);
        cliente.setNombres(nombres);
        cliente.setDniRuc(dni);
        cliente.setEmail(email);
        cliente.setTelefono(telefono);
        cliente.setDireccion(direccion);
        cliente.setDescripcion(descripcion);

        /*
        ClienteInterfazDAO clienteDAO = new ClienteImplementsDAO();
        ClienteInterfazService clienteService = new ClienteImplementsService();
        clienteService.setEntityManagerFactory(emf);
        clienteService.crearCliente(cliente);
        */


        cliente2=null;
        EntityManager em = null;
        em = emf.createEntityManager();
        em.getTransaction().begin();
        try{
            System.out.println("Hacer primera insercion");
            em.persist(cliente);
            //System.out.println("El id es: "+cliente.getId());
            System.out.println("Bien Hecha");
            System.out.println("Hacer segunda insercion");
            em.persist(cliente2);
            System.out.println("Bien Hecha");
            em.getTransaction().commit();
            System.out.println("Se Hizo commit");
        }catch(Exception e)
        {
            System.out.println("Hacermos RollBack");
            em.getTransaction().rollback();
            System.out.println("Se Hizo RollBack");
        }
        finally{
            System.out.println("Se va a cerrar");
            em.close();
            System.out.println("Se cerró");
        }
    }


    public static void crearUnCliente()
    {
        System.out.println("****Crearemos un nuevo Cliente");
        String nombres = "Juan Alvarado Florian";
        String dni = "564562";
        String email = "alvarado@hotmail.com";
        String telefono ="654564";
        String direccion = "Florencia de Mora";
        String descripcion = "Nada";

        FidCliente cliente = new FidCliente();
        cliente.setCantVentas(1);
        cliente.setSaldo(10.0);
        cliente.setNombres(nombres);
        cliente.setDniRuc(dni);
        cliente.setEmail(email);
        cliente.setTelefono(telefono);
        cliente.setDireccion(direccion);
        cliente.setDescripcion(descripcion);

        PersonaEmpresaInterfazService personaService = new PersonaEmpresaImplementsService();
        personaService.setEntityManagerFactory(emf);
        FidPersonaEmpresa cliente1= (FidPersonaEmpresa) personaService.buscar(7);
        System.out.println ("Mira esto" + cliente1.getDniRuc());
        cliente1.getNombres();
     //   personaService.
    }

    public static void editarCliente(int id){
        EntityManager em = emf.createEntityManager();
        FidCliente cliente = em.getReference(FidCliente.class, id);
        cliente.setDescripcion("humano impulsivo");
        PersonaEmpresaInterfazService personaService = new PersonaEmpresaImplementsService();
        personaService.setEntityManagerFactory(emf);
        personaService.modificar(cliente);
    }

    public static void buscarCliente(){
        PersonaEmpresaInterfazService personaService = new PersonaEmpresaImplementsService();
        personaService.setEntityManagerFactory(emf);
        String keyword = "id";  //nombre de la variable de busqueda
        int valorKey = 4;
        //por ahora busca al padre 
        FidPersonaEmpresa p = (FidPersonaEmpresa) personaService.buscar(keyword, valorKey);
        System.out.println("1. El buscado es = "+p.getNombres());

        //metodo de joao
        FidPersonaEmpresa p1= (FidPersonaEmpresa) personaService.buscar(4);
        System.out.println ("2. El buscado por joao es = " + p1.getNombres());

        //metodo de jorge para busqueda del hijo
        valorKey = 13;
        //test1
        FidCliente cli = (FidCliente) personaService.buscar(keyword, valorKey);
        System.out.println("3. El cliente buscado es = "+cli.getNombres());

        keyword="dniRuc";
        String valorKey2="45857402";
        //test2
        FidCliente cli2 = (FidCliente) personaService.buscar(keyword, valorKey2);
        System.out.println("4. El cliente buscado es = "+cli2.getNombres());

        keyword="fechaNac";
        Date valorKey3= new Date();
        valorKey3.setYear(87);
        valorKey3.setMonth(8); //septiembre, tener en cuenta que va de 0-11
        valorKey3.setDate(25);
        //test3
        FidCliente cli3 = (FidCliente) personaService.buscar(keyword, valorKey3);
        System.out.println("5. El cliente buscado es = "+cli3.getNombres());

        keyword="cantVentas";
        int valorKey4=2;
        //test4 importante por que busca por campos exclusivos del hijo y que el padre no tiene
        FidCliente cli4 = (FidCliente) personaService.buscar("FidCliente",keyword, valorKey4);
        System.out.println("6. El cliente buscado es = "+cli4.getNombres());
    }


     public static void borrarCliente(int id){
        EntityManager em = emf.createEntityManager();
        FidCliente cliente = em.getReference(FidCliente.class, id);
        PersonaEmpresaInterfazService personaService = new PersonaEmpresaImplementsService();
        personaService.setEntityManagerFactory(emf);
        personaService.eliminar(cliente);
     }







    // FID TRABAJADOR

    public static void crearTrabajador(FidTrabajador ft)
    {
        EntityManager em = null;
        try {
            em = emf.createEntityManager();
            em.getTransaction().begin();
            em.persist(ft);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }


    // FID ROL TRABAJADOR

    public static void crearRolTrabajador(FidRolTrabajador frt)
    {
        EntityManager em = null;
        try {
            em = emf.createEntityManager();
            em.getTransaction().begin();
            em.persist(frt);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public static FidRolTrabajador buscarFidRolTrabajador(Integer id) {
        EntityManager em = emf.createEntityManager();
        try {
            return em.find(FidRolTrabajador.class, id);
        } finally {
            em.close();
        }
    }

    public static void editarRolTrabajador(FidRolTrabajador frt)
    {
        EntityManager em = null;
        try {
            em = emf.createEntityManager();
            em.getTransaction().begin();
            frt = em.merge(frt);    // Actualiza los datos modificados
            em.getTransaction().commit();
        }finally{
            if (em != null) {
                em.close();
            }
        }
    }

    public static void eliminarFidRolTrabajador(int id)
    {
        EntityManager em = null;
        try {
            em = emf.createEntityManager();
            em.getTransaction().begin();
            FidRolTrabajador fidRolTrabajador = null;
            try {
                fidRolTrabajador = em.getReference(FidRolTrabajador.class, id);
                fidRolTrabajador.getId();
            } catch (EntityNotFoundException e) {}
            em.remove(fidRolTrabajador);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public static List<FidRolTrabajador> listarRolTrabajador(boolean band,String consulta, boolean todo, int tope, int desde)
    {
        if(!band){  // en caso no s haya ingresado una consulta jpql band=false
            consulta="select object(o) from FidRolTrabajador as o";
        }

        EntityManager em = emf.createEntityManager();
        try {
            Query q = em.createQuery(consulta);
            if (!todo) {// esto nos permitira hacer una paginación
                q.setMaxResults(tope);
                q.setFirstResult(desde);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }






}
